home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / l2r.lha / l2r / lex.lalr < prev    next >
Text File  |  1992-08-20  |  5KB  |  197 lines
  1. /************************************************************************/
  2. /*                                    */
  3. /* specification of parser for lex input language in lalr syntax    */
  4. /*                                    */
  5. /************************************************************************/
  6.  
  7. GLOBAL {
  8.  
  9. #include <stdio.h>
  10.  
  11. typedef struct { tScanAttribute Scan; } tParsAttribute;
  12.  
  13. static int in_defs = 1;    /* parsing definition part             */
  14. static char macro [256];/* regular expression for macro definition    */
  15. static int  m;        /* index for macro                */
  16. static int level = 0;    /* level count to decide on meaning of $    */
  17.  
  18. /* output representation for character, see print_char            */
  19. static char how_to_print [] =
  20. { 0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
  21.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  22.   1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
  23.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2,
  24.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  25.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1,
  26.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  27.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 0 };
  28.  
  29. /* in definition part, append v to macro, otherwise copy to buffer    */
  30. static void str_put (v)
  31.    char * v;
  32. {
  33.   if (in_defs) {
  34.     while (macro [m++] = *v++);
  35.     m--;
  36.   }
  37.   else BufString (v);
  38. }
  39.  
  40. /* print one character, escape if necessary                */
  41. static void print_char (c)
  42.    char c;
  43. {
  44.   char i;
  45.   char v [8];
  46.  
  47.   i = how_to_print [c];
  48.   switch (i) {
  49.     case 0    : (void) sprintf (v, "\\%d", c); break;
  50.     case 1    : (void) sprintf (v,   "%c", c); break;
  51.     case 2    : (void) sprintf (v, "\\%c", c); break;
  52.     default    : (void) sprintf (v, "\\%c", i); break;
  53.   }
  54.   str_put (v);
  55. }
  56.  
  57. /* print the default rules for lex compatibility            */
  58. default_rules ()
  59. {
  60.   str_put ("\" \"    :- { yyEcho; }\n");
  61.   str_put ("\\t    :- { yyTab; yyEcho; }\n");
  62.   str_put ("\\n    :- { yyEol (0); yyEcho; }\n");
  63. }
  64. }
  65.  
  66. TOKEN
  67.     '%%'        = 1
  68.     
  69.     STARTDEF    = 4
  70.     '%t'        = 5
  71.     '/'        = 6
  72.     '.'        = 7
  73.     '?'        = 8
  74.     '+'        = 9
  75.     '*'        = 10
  76.     '('        = 11
  77.     ')'        = 12
  78.     '|'        = 13
  79.     ACTION        = 14
  80.     STARTCOND    = 15
  81.     REPEAT        = 16
  82.     EXPANSION    = 17
  83.     '^'        = 18
  84.     PSEUDOACTION    = 19
  85.     STRING        = 20
  86.     CHARCLASS    = 21
  87.     CHAR        = 22
  88.     MACRODEF    = 23
  89.     TRANSLATION    = 24
  90.     '\n'        = 25
  91.     '$'        = 26
  92.  
  93. RULE
  94.  
  95. (************************************************************************)
  96. (*                                    *)
  97. (* syntax of lex source file                        *)
  98. (*                                    *)
  99. (* lex source consists of a definition part, a rule part and an        *)
  100. (* optional subprograms part, which are separated by lines beginning    *)
  101. (* with '%%'.                                *)
  102. (*                                    *)
  103. (************************************************************************)
  104.  
  105. source        : defs '%%' { in_defs = 0; str_put ("\nRULES\n\n"); }
  106.           rules { default_rules (); } [ '%%' ] .
  107.  
  108.  
  109. (************************************************************************)
  110. (*                                    *)
  111. (* definition part                            *)
  112. (*                                    *)
  113. (* consists of an arbitrary number of definitions (even 0).        *)
  114. (*                                    *)
  115. (************************************************************************)
  116.  
  117. defs        : ( def  '\n' ) * .
  118.  
  119.  
  120. (* syntax of single definition                         *)
  121. def        : macrodef expr { str_put (" ."); put_macro (macro); level--; }
  122.         | STARTDEF
  123.         | '%t' ( TRANSLATION '\n' ) * '%t'
  124.         { (void) fprintf (stderr, "WARNING: translation table ignored !\n"); }
  125.         |
  126.         .
  127.  
  128. macrodef    : MACRODEF { m = 0;
  129.                  str_put ((char *) $1.Scan.string_value);
  130.                  str_put (" = ");
  131.                  level++; } .
  132.  
  133. (************************************************************************)
  134. (*                                    *)
  135. (* rule part                                *)
  136. (*                                    *)
  137. (* consists of an arbitrary number of rules (even 0).            *)
  138. (*                                    *)
  139. (************************************************************************)
  140.  
  141. rules        : ( rule '\n' { str_put ("\n"); } ) * .
  142.  
  143. rule        : [ startcond caret fullexpr [ endcond ] ] action . 
  144.  
  145. startcond    : STARTCOND { str_put ((char *) $1.Scan.string_value); str_put (" "); } .
  146. startcond    : .
  147.  
  148. caret        : '^' { str_put ("< "); } .
  149. caret        : .
  150.  
  151. endcond        : '/'     { str_put (" / "); } expr .
  152.  
  153. fullexpr    : fullexpr '|' { str_put (" , "); } term .
  154. fullexpr    : term .
  155.  
  156. expr        : expr  '|' { str_put ("|"); } term .
  157. expr        : term .
  158.  
  159. term        : factor repeat .
  160.  
  161. repeat        : REPEAT { str_put ((char *) $1.Scan.string_value); } .
  162. repeat        : .
  163.  
  164. factor        : factor secondary .
  165. factor         : secondary .
  166.  
  167. secondary    : primary '?'    { str_put ("?"); }
  168.         | primary '*'    { str_put ("*"); }
  169.         | primary '+'    { str_put ("+"); }
  170.         | primary
  171.         .
  172.  
  173.  
  174. primary        : '(' { str_put ("("); level++; } expr ')'
  175.             { str_put (")"); level--; }
  176.         | EXPANSION { str_put ((char *) $1.Scan.string_value); }
  177.         | CHARCLASS { str_put ((char *) $1.Scan.string_value); }
  178.         | '.'    { str_put (" ANY "); }
  179.         | STRING    { str_put ((char *) $1.Scan.string_value); }
  180.         | CHAR    { print_char ((char) $1.Scan.char_value); }
  181.         | '$'    { if (level != 0)
  182.                 { str_put ("$"); }
  183.               else
  184.                 str_put (" >"); }
  185.         .
  186.  
  187. action        : { str_put ("    : { (void) GetWord (yytext); "); }
  188.           action_1 { str_put (" }"); }
  189.         | PSEUDOACTION    { str_put (" ,"); }
  190.         |
  191.         .
  192.  
  193. action_1    : action_1 action_2 .
  194. action_1    : action_2 .
  195.  
  196. action_2    : ACTION { str_put ((char *) $1.Scan.string_value); } .
  197.